Essentially, this makes three improvement:
1. Add types to allow the creation of error/warning/Fix-It messages from string literals. These types have a static diagnostic ID but I think that should be sufficient for most macros.
2. Add a convenience initializer to `Diagnostic` to create it with a single Fix-It, eliminating the need to create an array literal containing all Fix-Its
3. Add a static method on `FixIt` to create a Fix-It with a single `replace` change.

This simplifies the creation of a simple diagnostic from

```swift
let diagnosticDomain = "AddCompletionHandlerMacro"

struct CanOnlyBeAppliedDoAsyncFunctionErrorMessage: DiagnosticMessage {
  let message: String
  var diagnosticID: SwiftDiagnostics.MessageID { .init(domain: diagnosticDomain, id: "\(Self.self)") }
  var severity: SwiftDiagnostics.DiagnosticSeverity { .error }

  init(_ funcDecl: FunctionDeclSyntax) {
    message = "can only add a \(funcDecl) completion-handler variant to an 'async' function"
  }
}

enum AddCompletionHandlerFixItMessage: FixItMessage {
  case addAsync

  var fixItID: SwiftDiagnostics.MessageID { .init(domain: diagnosticDomain, id: "\(Self.self)") }

  var message: String {
    switch self {
    case .addAsync: return "add 'async'"
    }
  }
}

let diagnostic = Diagnostic(
  node: Syntax(funcDecl.funcKeyword),
  message: CanOnlyBeAppliedDoAsyncFunctionErrorMessage(funcDecl),
  fixIt: FixIt(
    message: AddCompletionHandlerFixItMessage.addAsync,
    changes: [
      .replace(oldNode: Syntax(funcDecl.signature), newNode: Syntax(newSignature))
    ]
  )
)
```

to

```swift
let diagnostic = Diagnostic(
  node: funcDecl.funcKeyword,
  message: MacroExpansionErrorMessage("can only add a \(node) completion-handler variant to an 'async' function"),
  fixIt: FixIt.replace(
    message: MacroExpansionFixItMessage("add 'async'")
    oldNode: funcDecl.signature,
    newNode: newSignature
  )
)
```